const axios = require('axios');
const fs = require('fs');
const path = require('path');

// 测试配置
const CONFIG = {
  baseURL: 'http://localhost:3000/api/v1', // 正确的API前缀
  testUser: {
    username: 'user',
    password: '123456'
  },
  outputFile: path.join(__dirname, 'test_message_results.md')
};

/**
 * 记录测试结果到控制台和文件
 * @param {string} message - 要记录的消息
 */
function logResult(message) {
  console.log(message);
  fs.appendFileSync(CONFIG.outputFile, message + '\n');
}

/**
 * 初始化测试结果文件
 */
function initTestFile() {
  fs.writeFileSync(CONFIG.outputFile, '# 用户消息功能测试结果\n\n');
  fs.appendFileSync(CONFIG.outputFile, `测试时间: ${new Date().toLocaleString()}\n\n`);
}

/**
 * 登录获取token
 * @returns {Promise<Object>} 包含登录状态、token和用户信息的对象
 */
async function login() {
  try {
    logResult(`正在登录用户: ${CONFIG.testUser.username}`);
    logResult(`尝试登录: ${CONFIG.baseURL}/auth/login`);
    
    // 使用简单配置避免序列化问题
    const response = await axios.post(`${CONFIG.baseURL}/auth/login`, {
      username: CONFIG.testUser.username,
      password: CONFIG.testUser.password
    }, { timeout: 10000 });
    
    logResult(`登录响应状态码: ${response.status}`);
    
    if (response.data.success && response.data.data && response.data.data.tokens && response.data.data.tokens.accessToken) {
      logResult('✅ 登录成功！');
      logResult(`用户ID: ${response.data.data.user.id}`);
      logResult(`用户名: ${response.data.data.user.username}`);
      logResult(`昵称: ${response.data.data.user.nickname || '未设置'}`);
      return {
        success: true,
        token: response.data.data.tokens.accessToken,
        user: response.data.data.user
      };
    } else {
      logResult('❌ 登录失败: 未找到accessToken');
      return { success: false, error: '登录响应中未找到accessToken' };
    }
  } catch (error) {
    logResult(`❌ 登录失败: ${error.message}`);
    if (error.response) {
        logResult(`❌ 响应状态: ${error.response.status}`);
        try {
          logResult(`❌ 响应数据: ${JSON.stringify(error.response.data)}`);
        } catch (e) {
          logResult(`❌ 响应数据: [无法序列化]`);
        }
      } else if (error.request) {
        logResult(`❌ 请求已发送但未收到响应`);
      } else {
        logResult(`❌ 请求配置错误: ${error.message}`);
      }
    return { success: false, error: error.message };
  }
}

/**
 * 测试获取消息列表接口
 * @param {string} token - 认证token
 * @returns {Promise<Object>} 测试结果
 */
async function testGetMessages(token) {
  try {
    logResult('\n开始测试获取消息列表接口...');
    logResult(`请求URL: ${CONFIG.baseURL}/messages`);
    
    const response = await axios.get(`${CONFIG.baseURL}/messages`, {
      headers: {
        'Authorization': `Bearer ${token}`
      },
      params: {
        page: 1,
        limit: 10,
        type: null // null表示获取所有类型消息
      }
    });
    
    logResult(`响应状态码: ${response.status}`);
    logResult(`消息总数: ${response.data.data.pagination.total}`);
    logResult(`当前页消息数量: ${response.data.data.messages.length}`);
    logResult(`分页信息: ${JSON.stringify(response.data.data.pagination)}`);
    
    if (response.data.data.messages.length > 0) {
        logResult('前5条消息信息:');
        response.data.data.messages.slice(0, 5).forEach((message, index) => {
          const senderNickname = message.fromUser ? message.fromUser.nickname : '未知';
          const messageInfo = `${index + 1}. ID: ${message.id}, 类型: ${message.type}, 发送者: ${message.from_user_id} (昵称: ${senderNickname}), 内容: ${message.content.substring(0, 50)}${message.content.length > 50 ? '...' : ''}`;
          logResult(messageInfo);
        });
      }
    
    logResult('✅ 获取消息列表成功！');
    return { success: true, data: response.data };
  } catch (error) {
    logResult(`❌ 获取消息列表失败`);
    logResult(`❌ 异常信息: ${error.message}`);
    if (error.response) {
      logResult(`❌ 响应状态: ${error.response.status}`);
      logResult(`❌ 响应数据: ${JSON.stringify(error.response.data)}`);
    }
    return { success: false, error: error.response?.data || error.message };
  }
}

/**
 * 测试获取未读消息数量接口
 * @param {string} token - 认证token
 * @returns {Promise<Object>} 测试结果
 */
async function testGetUnreadCount(token) {
  try {
    logResult('\n开始测试获取未读消息数量接口...');
    logResult(`请求URL: ${CONFIG.baseURL}/messages/unread/count`);
    
    const response = await axios.get(`${CONFIG.baseURL}/messages/unread/count`, {
      headers: {
        'Authorization': `Bearer ${token}`
      }
    });
    
    logResult(`响应状态码: ${response.status}`);
    logResult(`未读消息总数: ${response.data.data.total}`);
    logResult(`点赞未读消息数: ${response.data.data.likeCount || 0}`);
    logResult(`评论未读消息数: ${response.data.data.commentCount || 0}`);
    
    logResult('✅ 获取未读消息数量成功！');
    return { success: true, data: response.data };
  } catch (error) {
    logResult(`❌ 获取未读消息数量失败`);
    logResult(`❌ 异常信息: ${error.message}`);
    if (error.response) {
      logResult(`❌ 响应状态: ${error.response.status}`);
      logResult(`❌ 响应数据: ${JSON.stringify(error.response.data)}`);
    }
    return { success: false, error: error.response?.data || error.message };
  }
}

/**
 * 测试标记单条消息为已读接口
 * @param {string} token - 认证token
 * @param {number} messageId - 消息ID
 * @returns {Promise<Object>} 测试结果
 */
async function testMarkMessageAsRead(token, messageId) {
  try {
    logResult(`\n开始测试标记单条消息为已读接口...`);
    logResult(`请求URL: ${CONFIG.baseURL}/messages/${messageId}/read`);
    
    const response = await axios.put(`${CONFIG.baseURL}/messages/${messageId}/read`, {}, {
      headers: {
        'Authorization': `Bearer ${token}`
      }
    });
    
    logResult(`响应状态码: ${response.status}`);
    logResult(`响应数据: ${JSON.stringify(response.data)}`);
    
    logResult('✅ 标记消息已读成功！');
    return { success: true, data: response.data };
  } catch (error) {
    logResult(`❌ 标记消息已读失败`);
    logResult(`❌ 异常信息: ${error.message}`);
    if (error.response) {
      logResult(`❌ 响应状态: ${error.response.status}`);
      logResult(`❌ 响应数据: ${JSON.stringify(error.response.data)}`);
    }
    return { success: false, error: error.response?.data || error.message };
  }
}

/**
 * 测试标记全部消息为已读接口
 * @param {string} token - 认证token
 * @returns {Promise<Object>} 测试结果
 */
async function testMarkAllAsRead(token) {
  try {
    logResult('\n开始测试标记全部消息为已读接口...');
    logResult(`请求URL: ${CONFIG.baseURL}/messages/read-all`);
    
    // 先不指定类型，标记所有消息
    const response = await axios.put(`${CONFIG.baseURL}/messages/read-all`, {}, {
      headers: {
        'Authorization': `Bearer ${token}`
      }
    });
    
    logResult(`响应状态码: ${response.status}`);
    logResult(`响应数据: ${JSON.stringify(response.data)}`);
    
    logResult('✅ 标记全部消息已读成功！');
    return { success: true, data: response.data };
  } catch (error) {
    logResult(`❌ 标记全部消息已读失败`);
    logResult(`❌ 异常信息: ${error.message}`);
    if (error.response) {
      logResult(`❌ 响应状态: ${error.response.status}`);
      logResult(`❌ 响应数据: ${JSON.stringify(error.response.data)}`);
    }
    return { success: false, error: error.response?.data || error.message };
  }
}

/**
 * 测试删除消息接口
 * @param {string} token - 认证token
 * @param {number} messageId - 消息ID
 * @returns {Promise<Object>} 测试结果
 */
async function testDeleteMessage(token, messageId) {
  try {
    logResult(`\n开始测试删除消息接口...`);
    logResult(`请求URL: ${CONFIG.baseURL}/messages/${messageId}`);
    
    const response = await axios.delete(`${CONFIG.baseURL}/messages/${messageId}`, {
      headers: {
        'Authorization': `Bearer ${token}`
      }
    });
    
    logResult(`响应状态码: ${response.status}`);
    logResult(`响应数据: ${JSON.stringify(response.data)}`);
    
    logResult('✅ 删除消息成功！');
    return { success: true, data: response.data };
  } catch (error) {
    logResult(`❌ 删除消息失败`);
    logResult(`❌ 异常信息: ${error.message}`);
    if (error.response) {
      logResult(`❌ 响应状态: ${error.response.status}`);
      logResult(`❌ 响应数据: ${JSON.stringify(error.response.data)}`);
    }
    return { success: false, error: error.response?.data || error.message };
  }
}

/**
 * 主测试函数
 */
async function runTests() {
  try {
    // 初始化测试文件
    initTestFile();
    logResult('开始用户消息功能测试...');
    
    // 1. 登录
    const loginResult = await login();
    if (!loginResult.success) {
      logResult('\n❌ 测试失败: 无法登录');
      process.exit(1);
    }
    
    const { token, user } = loginResult;
    let firstMessageId = null;
    
    // 2. 测试获取消息列表
    const messagesResult = await testGetMessages(token);
    if (!messagesResult.success) {
      logResult('\n❌ 测试失败: 获取消息列表失败');
      process.exit(1);
    }
    
    // 保存第一条消息ID用于后续测试
    if (messagesResult.data.data.messages && messagesResult.data.data.messages.length > 0) {
      firstMessageId = messagesResult.data.data.messages[0].id;
      logResult(`\n获取到第一条消息ID: ${firstMessageId}`);
    }
    
    // 3. 测试获取未读消息数量
    const unreadResult = await testGetUnreadCount(token);
    if (!unreadResult.success) {
      logResult('\n❌ 测试失败: 获取未读消息数量失败');
      process.exit(1);
    }
    
    // 4. 如果有消息，测试标记单条消息已读
    if (firstMessageId) {
      const markReadResult = await testMarkMessageAsRead(token, firstMessageId);
      if (!markReadResult.success) {
        logResult('\n❌ 测试失败: 标记单条消息已读失败');
        process.exit(1);
      }
    } else {
      logResult('\n⚠️  未找到消息，跳过标记单条消息已读测试');
    }
    
    // 5. 测试标记全部消息已读
    const markAllReadResult = await testMarkAllAsRead(token);
    if (!markAllReadResult.success) {
      logResult('\n❌ 测试失败: 标记全部消息已读失败');
      process.exit(1);
    }
    
    // 6. 测试删除消息
    if (firstMessageId) {
      const deleteResult = await testDeleteMessage(token, firstMessageId);
      if (!deleteResult.success) {
        logResult('\n❌ 测试失败: 删除消息失败');
        process.exit(1);
      }
    } else {
      logResult('\n⚠️  未找到消息，跳过删除消息测试');
    }
    
    logResult('\n🎉 所有消息功能测试通过！');
    process.exit(0);
  } catch (error) {
    logResult(`\n❌ 测试过程中发生未预期错误: ${error}`);
    process.exit(1);
  }
}

// 运行测试
runTests();